<template>
  <section>
    <Header title="Code" :onRightClick="onRightClick" />
  </section>
</template>
<script>
import { Header } from '@/components'
export default {
  name: 'SEARCH',
  components: {
    Header
  },
  data () {
    return {
    }
  },
  methods: {
    onRightClick () {
      this.$Jump2('index')
    }
  }
}

/** Javascript code start */
// function object(o) {
// 	function F() {}
// 	F.prototype = o
//   return new F()
// }

// function inheritPrototype(subType, superType) {
//   const prototype = object(superType.prototype)
//   prototype.constructor = subType
//   subType.prototype = prototype
// }

// function SuperType (name) {
//   this.name = name
//   this.colors = ['red', 'blue', 'green']
// }
// SuperType.prototype.sayName = function () {
//   console.log(this.name)
// }
// function SubType (name, age) {
//   SuperType.call(this, name) // 继承属性
//   this.age = age
// }

// inheritPrototype(SubType, SuperType) // 继承方法-原型链混成
// SubType.prototype.sayAge = function () {
//   console.log(this.age)
// }

// const ins = new SubType('xiaochen', 18)
// console.log(ins)

// ES6继承
// class Point {
//   // ES2022新规，定义在顶层的属性是为实例属性
//   xiaochen = 18

//   constructor (x, y) {
//     this.x = x
//     this.y = y
//     console.log(`输出私有属性：`, this.#privateProp)
//   }

//   // 内部定义的方法是不可枚举的，ES5以及外部定义的都是可以枚举的
//   toString () {
//     return `x-y value is: ${this.x}-${this.y}`
//   }

//   getSum () {
//     return this.x + this.y
//   }

//   /**静态方法-可称之为class的方法，不在原型上，不被实例继承，由class自身调用，内有this也是指向的class
//    * 静态方法可以与非静态方法重名
//    * 父类的静态方法，可以被子类继承
//    * 静态方法也是可以从super对象上调用的
//    */
//   static classMethod () {
//     console.log('哈哈哈')
//   }
  
//   /**
//    * 静态属性，只能是通过this访问
//    */
//   static prop = 18

//   // 私有属性-只能在类内部使用，不限制于this，实例也可以访问
//   #privateProp = 'xiaochen'

//   // 自定义属性的赋值和取值行为
//   get xx() {
//     return this.x + 2
//   }
//   set xx(value) {
//     this.x = value
//   }
// }
// Point.classMethod()

// class Line extends Point {
//   static classMethod () {
//     return super.classMethod()
//   }
// }
// Line.classMethod()

// Object.assign(Point.prototype, {
//   getX () {},
//   getY () {}
// })

// const p1 = new Point(20, 90)
// console.log(p1)

// console.log('getter&setter: ', p1.xx)

// console.log('类方法枚举-keys：', Object.keys(Point.prototype))
// console.log('类方法枚举-getOwnPropertyNames：', Object.getOwnPropertyNames(Point.prototype))

// // class 表达式
// const MyClass = class {}
// const m1 = new MyClass()
// console.log('class表达式： ', m1)

/** ES5与ES6的构造函数区别
1. class内部定义的方法是不可枚举的，ES5以及ES6外部定义的都是可以枚举的。
2. class必须使用new调用，否则报错，ES5不用也可以执行。
3. class不存在变量提升,这种规定的原因与下文要提到的继承有关，必须保证子类在父类之后定义。
*/

// var color = 'blue'
// function changeColor() {
//   console.log(arguments) // Arguments 对象
//   if (color === 'blue') {
//     color = 'red'
//   } else {
//     color = 'blue'
//   }
// }
// changeColor()
// console.log(color) // red

// try {
//   throw new Error('catch')
// } catch (e) {
//   console.log(e)
// }

// function buildUrl () {
//   const qs = '?degub=true'

//   with(location) {
//     var url = href + qs
//   }
//   return url
// }

// if (true) {
//   var color = 'blue'
// }
// console.log(color) // blue

// function printNumber (count) {
//   (function () { // 这行
//     for (var i=0; i<count; i++) {
//       console.log(i)
//     }
//   })() // 这行
//   console.log('func scope: ', i) // error
// }
// printNumber(3)

</script>
